#include <iostream>
#include <string>
#include "myfunctions.h"

#include "testSamples.h"
#include "myTestSample.h"

using namespace std;

/*
 *  1. 常量指针
 *  const int *p = &a;
 *  指针p可以修改，但只有读的权限
 *
 *  2. 指针常量
 *  int * const p = &a;
 *  p是常量
 *
 *  3. const 既修饰指针，又修饰常量：
 *  const int * const p = &a;
 *  p是常量, a也是常量
 *
 *  ----------------------------------
 *  new 是就是用了一个malloc，需要用delete删除它
 *  int *p = new int(5);        // 用new申请了一个内存，大小是一个int，并进行了初始化，初值为5，返回了内存的首地址
 *
 *  ----------------------------------
 *  c++中的引用: 给变量取别名
 *  int a = 10;
 *  int &b = a;     //创建引用，b有读写权限
 *
 *  注意点：
 *      引用必须初始化，初始化以后就不能再修改
 *
 *
 * >>  引用在函数参数传递时可以代替指针操作
 * >> 下面两个函数完成了相同的功能
 * //  指针传递，调用方式: swap( &a, &b );
 *  void swap( int *pa, int *pb )
 *  {
 *      int t = *pa;
 *      *pa = *pb;
 *      *pb = t;
 *  }
 *
 *  // 引用传递， 调用方式: swap2( a,b )
 *  void swap2( int &a, int &b )
 *  {
 *      int t = a;
 *      a = b;
 *      b = t;
 *  }
 *
 *  >>  引用做函数的返回值：
 *  int& function()
 *  {
 *      static int a = 10;  // 重点在于static关键字。函数结束后它不会被清除
 *      return a;
 *  }
 *
 *  // 调用1:
 *  int &ref = function();  // 理解：使用指针的方式把ref变成function函数中变量static int a 的地址引用
 *
 *  // 调用2：函数当做左值
 *  function() = 100;       // 返回了static int a的引用，然后给这个引用赋值100，此时static int a已经变成了100
 *
 * >> c++中，引用起始是使用常量指针实现的
 *  int &ref = a; 这句话被编译器变成了： int * const pref = &a
 *
 *  >> 常量引用：使用const把形参只给读权限
 *  void func( int &a )
 *  {
 *      a = 100;        // 利用指针修改了a引用的内存的数值
 *  }
 *
 *  void func( const int &a )
 *  {
 *      a;  //  现在a只能有读权限了
 *  }
 *
 *
 *  ---------------------------------
 *  函数参数的默认值
 *  int func( int a = 10, int b = 1, int c = 2 )
 *  {
 *      return a+b+c;
 *  }
 *  调用:
 *  func(2);
 *
 *
 *
 * */


/*
int main()
{

    int i;
    for ( i=0; i<10; i++ )
            std::cout << myadd( i,i ) << std::endl;

    return 0;
}
 */



/*
#define PI (3.1415926535)

class Circle
{
    // 1. 访问权限
public:     //   公共访问权限

    // 2. 属性
    int m_r;        // 半径

    // 3. 行为
    // 行为通常是函数
    double getC()   // 计算周长
    {
        return ( 2 * PI * m_r );
    }



};


int main()
{
    Circle circle;

    circle.m_r = 5;

    std::cout<< "c = " << circle.getC() << std::endl;

}
*/

// 属性：成员属性 成员行为
//
/*
 * ----------------------------------------------
 * >> 构造函数的分类
 *
 *
 *
 * */

/*
class Stdudent {
public:
    string name;
    int id;

private:
    string sex;

public:

    Stdudent()
    {
        // 这是构造函数
        cout << "this is construct func" << endl;
    }

    // 拷贝构造函数
    Stdudent(const Stdudent &s )
    {
        name = s.name;
        id = s.id;
        setSex( s.sex );
    }

    Stdudent(int idx)
    {
        // 这是构造函数
        id = idx;
        cout << "this is construct func 3 " << endl;
    }
    ~Stdudent()
    {
        // 这是析构函数
        int i;
        for( i=0; i<1; i++ )
            cout<< "this is func 2" << endl;
    }



    // 行为：显示姓名和学号
    void showStudent()
    {
        cout << "name: " << name << " id: " << id << endl;
    }

    void showStudent(int)
    {
        cout << "name: " << name << " id: " << id << " sex: " << sex << endl;
    }

    void setSex( string sex_set )   // 利用函数设置参数sex的值
    {
        sex = sex_set;
    }
    string getSex( void )
    {
        return sex;
    }

};
*/

#include "Student.h"

/*
 * ing 138 纯虚函数和多态类
 * 139 done
 * TODO: 140
 * */

int main()
{
    myTestSample ts;
    ts.test05();
}



